home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Languages / PowerMacOberon 1.2 / Source / Tools / Make.Mod (.txt) < prev    next >
Oberon Text  |  1995-08-22  |  3KB  |  111 lines
  1. Syntax10.Scn.Fnt
  2. FoldElems
  3. Syntax10.Scn.Fnt
  4. (*-----------------------------------------------------------------------
  5. Make topologically sorts a set of Oberon source file names according to their import relationships
  6. so that they are in a correct compilation order. The generated list can be prepended with the
  7. command Compiler.Compile and can be compiled.
  8. Make.Order {filename} ~
  9.     reads a list of file names describing Oberon modules. The import relationships of these
  10.     modules are inspected and the modules are sorted accordingly. The sorted list of file names
  11.     is written to the standard output.
  12. -----------------------------------------------------------------------*)
  13. Syntax10i.Scn.Fnt
  14. StampElems
  15. Alloc
  16. 8 May 95
  17. Syntax10b.Scn.Fnt
  18. Documentation
  19. MODULE Make;  (*HM 94-06-22 / 
  20. IMPORT Texts, In, Out;
  21.     ModuleName = ARRAY 32 OF CHAR;
  22.     Import = POINTER TO ImportDesc;
  23.     Module = POINTER TO ModuleDesc;
  24.     ModuleDesc = RECORD
  25.         name: ModuleName;
  26.         imports: Import;
  27.         ref: INTEGER;
  28.         next: Module
  29.     END;
  30.     ImportDesc = RECORD
  31.         mod: Module;
  32.         next: Import;
  33.     END;
  34. PROCEDURE Append (VAR name: ModuleName; ext: ARRAY OF CHAR);
  35.     VAR i, j: INTEGER;
  36. BEGIN
  37.     i := 0; WHILE name[i] # 0X DO INC(i) END;
  38.     j := 0; WHILE ext[j] # 0X DO name[i] := ext[j]; INC(i); INC(j) END;
  39.     name[i] := 0X
  40. END Append;
  41. PROCEDURE ReadModuleList (VAR list: Module);
  42.     VAR m: Module;
  43. BEGIN
  44.     In.Open; list := NIL;
  45.     WHILE In.Next() = In.name DO
  46.         NEW(m); In.Name(m.name); m.imports := NIL; m.ref := 0; m.next := list; list := m
  47.     END;
  48. END ReadModuleList;
  49. PROCEDURE Find (list: Module; name: ModuleName; VAR m: Module);
  50. BEGIN
  51.     m := list;
  52.     WHILE (m # NIL) & (m.name # name) DO m := m.next END
  53. END Find;
  54. PROCEDURE FindTop (list: Module; VAR m, prev: Module);
  55. BEGIN
  56.     m := list; prev := NIL;
  57.     WHILE (m # NIL) & (m.ref # 0) DO prev := m; m := m.next END
  58. END FindTop;
  59. PROCEDURE FindImports (m, list: Module);
  60.     VAR t: Texts.Text; s: Texts.Scanner; p: Module; imp: Import; name: ModuleName;
  61. BEGIN
  62.     NEW(t); Texts.Open(t, m.name);
  63.     IF t.len > 0 THEN
  64.         Texts.OpenScanner(s, t, 0);
  65.         REPEAT Texts.Scan(s) UNTIL s.eot OR (s.class = Texts.Name) & (s.s = "IMPORT");
  66.         IF ~ s.eot THEN
  67.             REPEAT
  68.                 Texts.Scan(s);
  69.                 IF s.class = Texts.Name THEN
  70.                     COPY(s.s, name); Texts.Scan(s);
  71.                     IF (s.class = Texts.Char) & (s.c = ":") THEN Texts.Scan(s); Texts.Scan(s); COPY(s.s, name) END;
  72.                     Append(name, ".Mod");
  73.                     Find(list, name, p);
  74.                     IF p = NIL THEN NEW(p); p.name := name; p.imports := NIL; p.ref := 0 END;
  75.                     INC(p.ref);
  76.                     NEW(imp); imp.mod := p;
  77.                     imp.next := m.imports; m.imports := imp
  78.                 END
  79.             UNTIL (s.class = Texts.Char) & (s.c = ";")
  80.         END
  81. END FindImports;
  82. PROCEDURE Print (VAR list: Module);
  83.     VAR m, prev: Module; imp: Import;
  84. BEGIN
  85.     IF list # NIL THEN
  86.         FindTop(list, m, prev);
  87.         IF prev = NIL THEN list := m.next ELSE prev.next := m.next END;
  88.         imp := m.imports; WHILE imp # NIL DO DEC(imp.mod.ref); imp := imp.next END;
  89.         Print(list);
  90.         Out.String(m.name); Out.Ln
  91. END Print;
  92. PROCEDURE Order*;
  93.     VAR list, imports, p, m, last: Module;
  94. BEGIN
  95.     ReadModuleList(list);
  96.     m := list;
  97.     WHILE m # NIL DO FindImports(m, list); m := m.next END;
  98.     Print(list)
  99. END Order;
  100. END Make.
  101. Make.Order
  102. POPB.Mod
  103. POPC.Mod
  104. POPdump.Mod
  105. POPL.Mod
  106. POPM.Mod
  107. POPP.Mod
  108. POPS.Mod
  109. POPT.Mod
  110. POPV.Mod
  111.